package com.atguigu.tingshu.album.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;

	@Autowired
	private AlbumAttributeValueMapper albumAttributeValueMapper;

	@Autowired
	private AlbumStatMapper albumStatMapper;

	@Autowired
	private TrackInfoMapper trackInfoMapper;

	/**
	 * 保存专辑方法
	 * 1.将提交专辑VO转为PO对象，新增专辑
	 * 2.将提交专辑标签封装为专辑标签关系集合对象，进行批量保存
	 * 3.为新增专辑标签，批量保存专辑统计信息
	 *
	 * @param userId      用户ID
	 * @param albumInfoVo 专辑信息VO对象
	 */
	@Override
	@Transactional(rollbackFor = Exception.class) //默认事务注解修饰方法捕获运行时异常或者Error
	public void saveAlbumInfo(Long userId, AlbumInfoVo albumInfoVo) {
		//1.保存专辑
		//1.1 将提交专辑VO拷贝到专辑PO对象中 仅限同名同类型属性才会被拷贝
		AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);

		//1.2 手动为用户id、包含声音数量（0）、是否完结、免费试听集数、审核状态（TODO：审核通过，实则有内容审核机制）
		albumInfo.setUserId(userId);
		albumInfo.setIncludeTrackCount(0);
		albumInfo.setIsFinished("0");
		albumInfo.setTracksForFree(5);
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
		//1.3 保存专辑，得到专辑ID
		albumInfoMapper.insert(albumInfo);
		Long albumId = albumInfo.getId();

		//2.保存专辑标签关系
		//2.1 将提交专辑标签关系VO集合转为PO集合
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)) {
			//2.2 关联专辑ID批量保存专辑标签关系
			for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
				AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
				albumAttributeValue.setAlbumId(albumId);
				albumAttributeValueMapper.insert(albumAttributeValue);
			}

		}
		//3.保存专辑统计信息（4条）
		this.saveAlbumStat(albumId, SystemConstant.ALBUM_STAT_PLAY, 0);
		this.saveAlbumStat(albumId, SystemConstant.ALBUM_STAT_SUBSCRIBE, 0);
		this.saveAlbumStat(albumId, SystemConstant.ALBUM_STAT_BUY, 0);
		this.saveAlbumStat(albumId, SystemConstant.ALBUM_STAT_COMMENT, 0);
	}

	/**
	 * 保存专辑统计信息
	 * @param albumId 专辑ID
	 * @param statType 统计类型
	 * @param statNum 统计数量
	 */
	@Override
	public void saveAlbumStat(Long albumId, String statType, int statNum) {
		AlbumStat albumStat = new AlbumStat();
		albumStat.setAlbumId(albumId);
		albumStat.setStatType(statType);
		albumStat.setStatNum(statNum);
		albumStatMapper.insert(albumStat);
	}

	/**
	 * 查询当前用户专辑分页列表
	 *
	 * @param pageInfo       分页对象
	 * @param albumInfoQuery 查询条件对象
	 * @return
	 */
	@Override
	public Page<AlbumListVo> getUserAlbumPage(Page<AlbumListVo> pageInfo, AlbumInfoQuery albumInfoQuery) {
		return albumInfoMapper.getUserAlbumPage(pageInfo, albumInfoQuery);
	}


	/**
	 * 根据专辑ID删除专辑
	 *
	 * @param id
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void removeAlbumInfo(Long id) {
		//1.根据专辑ID查询该专辑下包含声音 如果关联声音则不允许删除
		LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(TrackInfo::getAlbumId, id);
		Long count = trackInfoMapper.selectCount(queryWrapper);
		if (count > 0) {
			throw new GuiguException(400, "该专辑下存在未删除声音！");
		}
		//2.根据主键删除专辑
		albumInfoMapper.deleteById(id);

		//3.根据专辑ID删除专辑标签
		LambdaQueryWrapper<AlbumAttributeValue> albumAttributeValueLambdaQueryWrapper = new LambdaQueryWrapper<>();
		albumAttributeValueLambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId, id);
		albumAttributeValueMapper.delete(albumAttributeValueLambdaQueryWrapper);

		//4.根据专辑ID删除专辑统计数据
		LambdaQueryWrapper<AlbumStat> albumStatLambdaQueryWrapper = new LambdaQueryWrapper<>();
		albumStatLambdaQueryWrapper.eq(AlbumStat::getAlbumId, id);
		albumStatMapper.delete(albumStatLambdaQueryWrapper);
	}

	/**
	 * 根据专辑ID查询专辑信息（包含专辑标签及值）
	 *
	 * @param id
	 * @return
	 */
	@Override
	public AlbumInfo getAlbumInfo(Long id) {
		//1.根据专辑ID主键查询专辑信息
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		//2.根据专辑ID查询标签列表
		if (albumInfo != null) {
			LambdaQueryWrapper<AlbumAttributeValue> queryWrapper = new LambdaQueryWrapper<>();
			queryWrapper.eq(AlbumAttributeValue::getAlbumId, id);
			List<AlbumAttributeValue> attributeValueList = albumAttributeValueMapper.selectList(queryWrapper);
			albumInfo.setAlbumAttributeValueVoList(attributeValueList);
		}
		return albumInfo;
	}

	/**
	 * 修改专辑信息
	 *
	 * @param id          专辑ID
	 * @param albumInfoVo 修改专辑信息VO对象
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
		//1.修改专辑信息
		//2.1 将修改专辑信息转为PO对象 封装专辑ID
		AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
		albumInfo.setId(id);
		//2.2 修改专辑
		albumInfoMapper.updateById(albumInfo);
		//2.修改专辑标签 先删再新增
		//2.1 根据专辑ID将以前关联标签记录全部删除
		LambdaQueryWrapper<AlbumAttributeValue> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(AlbumAttributeValue::getAlbumId, id);
		albumAttributeValueMapper.delete(queryWrapper);
		//2.2 在根据提交专辑标签做新增
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)) {
			//2.2 关联专辑ID批量保存专辑标签关系
			for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
				AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
				albumAttributeValue.setAlbumId(id);
				albumAttributeValueMapper.insert(albumAttributeValue);
			}
		}
	}


	/**
	 *  根据用户ID查询用户所有专辑列表
	 * @param userId
	 * @return
	 */
	@Override
	public List<AlbumInfo> findUserAllAlbumList(Long userId) {

		List<AlbumInfo> albumInfos = albumInfoMapper.selectList(
				new LambdaQueryWrapper<AlbumInfo>()
						.eq(AlbumInfo::getUserId, userId) // 等值查询条件
						.orderByDesc(AlbumInfo::getId)   // 按 id 降序排列
						.last("LIMIT 200")               // 限制查询结果为 200 条
		);
//		//1.创建条件构造器封装查询条件
//		LambdaQueryWrapper<AlbumInfo> queryWrapper = new LambdaQueryWrapper<>();
//		queryWrapper.eq(AlbumInfo::getUserId, userId);
//		//2.指定查询字段 select 后面列名称
//		queryWrapper.select(AlbumInfo::getId, AlbumInfo::getAlbumTitle, AlbumInfo::getStatus);
//		//3.TODO 避免小程序响应1千多条记录导致卡顿 需要指定加载数量  limit 200
//		queryWrapper.last("limit 200");
//		//4.设置排序按照最新专辑
//		queryWrapper.orderByDesc(AlbumInfo::getId);
		return albumInfos;
	}
}
